// RAP [rh] KeyBindingService disabed, since the implemented interface is not supported
///*******************************************************************************
// * Copyright (c) 2000, 2009 IBM Corporation and others.
// * All rights reserved. This program and the accompanying materials
// * are made available under the terms of the Eclipse Public License v1.0
// * which accompanies this distribution, and is available at
// * http://www.eclipse.org/legal/epl-v10.html
// *
// * Contributors:
// * IBM Corporation - initial API and implementation
// *******************************************************************************/
//package org.eclipse.ui.internal;
//
//import java.util.ArrayList;
//import java.util.Arrays;
//import java.util.Collections;
//import java.util.HashMap;
//import java.util.HashSet;
//import java.util.Iterator;
//import java.util.List;
//import java.util.Map;
//import java.util.Set;
//
//import org.eclipse.jface.action.IAction;
//import org.eclipse.ui.IKeyBindingService;
//import org.eclipse.ui.INestableKeyBindingService;
//import org.eclipse.ui.IWorkbenchPartSite;
//import org.eclipse.ui.IWorkbenchSite;
//import org.eclipse.ui.PlatformUI;
//import org.eclipse.ui.commands.ActionHandler;
//import org.eclipse.ui.commands.HandlerSubmission;
//import org.eclipse.ui.commands.IHandler;
//import org.eclipse.ui.commands.Priority;
//import org.eclipse.ui.contexts.EnabledSubmission;
//import org.eclipse.ui.internal.actions.CommandAction;
//import org.eclipse.ui.internal.handlers.CommandLegacyActionWrapper;
//
///**
// * This service provides a nestable implementation of a key binding service.
// * This class is provided for backwards compatibility only, and might be removed
// * in the future. All of the functionality is the class can be duplicated by
// * using the commands and contexts API.
// *
// * @since 2.0
// */
//public final class KeyBindingService implements INestableKeyBindingService {
//
// /**
// * The currently active nested service, if any. If there are no nested
// * services or none of them are active, then this value is <code>null</code>.
// */
// private IKeyBindingService activeService = null;
//
// /**
// * Whether this key binding service has been disposed. A disposed key
// * binding service should not be used again.
// */
// private boolean disposed;
//
// /**
// * The set of context identifiers enabled in this key binding service (not
// * counting any nested services). This set may be empty, but it is never
// * <code>null</code>.
// */
// private Set enabledContextIds = Collections.EMPTY_SET;
//
// /**
// * The list of context submissions indicating the enabled state of the
// * context. This does not include those from nested services. This list may
// * be empty, but it is never <code>null</code>.
// */
// private List enabledSubmissions = new ArrayList();
//
// /**
// * The map of handler submissions, sorted by command identifiers. This does
// * not include those from nested services. This map may be empty, but it is
// * never <code>null</code>.
// */
// private Map handlerSubmissionsByCommandId = new HashMap();
//
// /**
// * The context submissions from the currently active nested service. This
// * value is <code>null</code> if there is no currently active nested
// * service.
// */
// private List nestedEnabledSubmissions = null;
//
// /**
// * The handler submissions from the currently active nested service. This
// * value is <code>null</code> if there is no currently active handler
// * service.
// */
// private List nestedHandlerSubmissions = null;
//
// /**
// * The map of workbench part sites to nested key binding services. This map
// * may be empty, but is never <code>null</code>.
// */
// private final Map nestedServices = new HashMap();
//
// /**
// * The parent for this key binding service; <code>null</code> if there is
// * no parent. If there is a parent, then this means that it should not do a
// * "live" update of its contexts or handlers, but should make a call to the
// * parent instead.
// */
// private final KeyBindingService parent;
//
// /**
// * The site within the workbench at which this service is provided. This
// * value should not be <code>null</code>.
// */
// private IWorkbenchPartSite workbenchPartSite;
//
// /**
// * Constructs a new instance of <code>KeyBindingService</code> on a given
// * workbench site. This instance is not nested.
// *
// * @param workbenchPartSite
// * The site for which this service will be responsible; should
// * not be <code>null</code>.
// */
// public KeyBindingService(IWorkbenchPartSite workbenchPartSite) {
// this(workbenchPartSite, null);
// }
//
// /**
// * Constructs a new instance of <code>KeyBindingService</code> on a given
// * workbench site.
// *
// * @param workbenchPartSite
// * The site for which this service will be responsible; should
// * not be <code>null</code>.
// * @param parent
// * The parent key binding service, if any; <code>null</code> if
// * none.
// */
// KeyBindingService(IWorkbenchPartSite workbenchPartSite,
// KeyBindingService parent) {
// this.workbenchPartSite = workbenchPartSite;
// this.parent = parent;
// }
//
// /*
// * (non-Javadoc)
// *
// * @see org.eclipse.ui.INestableKeyBindingService#activateKeyBindingService(org.eclipse.ui.IWorkbenchSite)
// */
// public boolean activateKeyBindingService(IWorkbenchSite nestedSite) {
// if (disposed) {
// return false;
// }
//
// // Check if we should do a deactivation.
// if (nestedSite == null) {
// // We should do a deactivation, if there is one active.
// if (activeService == null) {
// // There is no active service. Do no work.
// return false;
// }
// // Deactivate the currently active nested service.
// deactivateNestedService();
// return true;
// }
//
// // Attempt to activate a service.
// final IKeyBindingService service = (IKeyBindingService) nestedServices
// .get(nestedSite);
//
// if (service == activeService) {
// // The service is already active, or already null
// return false;
// }
//
// deactivateNestedService();
// if (service!=null) {
// activateNestedService(service);
// }
// return true;
// }
//
// /**
// * Activates the given service without worrying about the currently active
// * service. This goes through the work of adding all of the nested context
// * ids as enabled submissions.
// *
// * @param service
// * The service to become active; if <code>null</code>, then
// * the reference to the active service is set to
// * <code>null</code> but nothing else happens.
// */
// private final void activateNestedService(final IKeyBindingService service) {
// if (disposed) {
// return;
// }
//
// /*
// * If I have a parent, and I'm the active service, then deactivate so
// * that I can make changes.
// */
// boolean active = false;
// boolean haveParent = (parent != null);
// if (haveParent) {
// active = (parent.activeService == this);
// if (active) {
// parent.deactivateNestedService();
// }
// }
//
// // Update the active service.
// activeService = service;
//
// // Check to see that the service isn't null.
// if (service == null) {
// return;
// }
//
// if (haveParent) {
// if (active) {
// parent.activateNestedService(this);
// }
//
// } else if (activeService instanceof KeyBindingService) {
// // I have no parent, so I can make the changes myself.
// final KeyBindingService nestedService = (KeyBindingService) activeService;
//
// // Update the contexts.
// nestedEnabledSubmissions = nestedService.getEnabledSubmissions();
// normalizeSites(nestedEnabledSubmissions);
// PlatformUI.getWorkbench().getContextSupport().addEnabledSubmissions(
// nestedEnabledSubmissions);
//
// // Update the handlers.
// nestedHandlerSubmissions = nestedService.getHandlerSubmissions();
// normalizeSites(nestedHandlerSubmissions);
// PlatformUI.getWorkbench().getCommandSupport().addHandlerSubmissions(
// nestedHandlerSubmissions);
// }
// }
//
// /**
// * Deactives the currently active service. This nulls out the reference, and
// * removes all the enabled submissions for the nested service.
// */
// private final void deactivateNestedService() {
// if (disposed) {
// return;
// }
//
// // Don't do anything if there is no active service.
// if (activeService == null) {
// return;
// }
//
// // Check to see if there is a parent.
// boolean active = false;
// if (parent != null) {
// // Check if I'm the active service.
// if (parent.activeService == this) {
// active = true;
// // Deactivate myself so I can make changes.
// parent.deactivateNestedService();
// }
//
// } else if (activeService instanceof KeyBindingService) {
// // Remove all the nested context ids.
// PlatformUI.getWorkbench().getContextSupport()
// .removeEnabledSubmissions(nestedEnabledSubmissions);
//
// /*
// * Remove all of the nested handler submissions. The handlers here
// * weren't created by this instance (but by the nest instance), and
// * hence can't be disposed here.
// */
// PlatformUI.getWorkbench().getCommandSupport()
// .removeHandlerSubmissions(nestedHandlerSubmissions);
//
// }
//
// // Clear our reference to the active service.
// activeService = null;
//
// // If necessary, let my parent know that changes have occurred.
// if (active) {
// parent.activateNestedService(this);
// }
// }
//
// /**
// * Disposes this key binding service. This clears out all of the submissions
// * held by this service, and its nested services.
// */
// public void dispose() {
// if (!disposed) {
// deactivateNestedService();
// disposed = true;
//
// PlatformUI.getWorkbench()
// .getContextSupport()
// .removeEnabledSubmissions(new ArrayList(enabledSubmissions));
// enabledSubmissions.clear();
//
// /*
// * Each removed handler submission, must dispose its corresponding
// * handler -- as these handlers only exist inside of this class.
// */
// final List submissions = new ArrayList(
// handlerSubmissionsByCommandId.values());
// final Iterator submissionItr = submissions.iterator();
// while (submissionItr.hasNext()) {
// ((HandlerSubmission) submissionItr.next()).getHandler()
// .dispose();
// }
// PlatformUI.getWorkbench().getCommandSupport()
// .removeHandlerSubmissions(submissions);
// handlerSubmissionsByCommandId.clear();
//
// for (Iterator iterator = nestedServices.values().iterator(); iterator
// .hasNext();) {
// KeyBindingService keyBindingService = (KeyBindingService) iterator
// .next();
// keyBindingService.dispose();
// }
//
// nestedEnabledSubmissions = null;
// nestedHandlerSubmissions = null;
// nestedServices.clear();
// }
// }
//
// /**
// * Gets a copy of all the enabled submissions in the nesting chain.
// *
// * @return All of the nested enabled submissions -- including the ones from
// * this service. This list may be empty, but is never
// * <code>null</code>.
// */
// private final List getEnabledSubmissions() {
// if (disposed) {
// return null;
// }
//
// final List submissions = new ArrayList(enabledSubmissions);
// if (activeService instanceof KeyBindingService) {
// final KeyBindingService nestedService = (KeyBindingService) activeService;
// submissions.addAll(nestedService.getEnabledSubmissions());
// }
// return submissions;
// }
//
// /**
// * Gets a copy of all the handler submissions in the nesting chain.
// *
// * @return All of the nested handler submissions -- including the ones from
// * this service. This list may be empty, but is never
// * <code>null</code>.
// */
// private final List getHandlerSubmissions() {
// if (disposed) {
// return null;
// }
//
// final List submissions = new ArrayList(handlerSubmissionsByCommandId
// .values());
// if (activeService instanceof KeyBindingService) {
// final KeyBindingService nestedService = (KeyBindingService) activeService;
// submissions.addAll(nestedService.getHandlerSubmissions());
// }
// return submissions;
// }
//
// /*
// * (non-Javadoc)
// *
// * @see org.eclipse.ui.INestableKeyBindingService#getKeyBindingService(org.eclipse.ui.IWorkbenchSite)
// */
// public IKeyBindingService getKeyBindingService(IWorkbenchSite nestedSite) {
// if (disposed) {
// return null;
// }
//
// if (nestedSite == null) {
// return null;
// }
//
// IKeyBindingService service = (IKeyBindingService) nestedServices
// .get(nestedSite);
// if (service == null) {
// // TODO the INestedKeyBindingService API should be based on
// // IWorkbenchPartSite..
// if (nestedSite instanceof IWorkbenchPartSite) {
// service = new KeyBindingService(
// (IWorkbenchPartSite) nestedSite, this);
// } else {
// service = new KeyBindingService(null, this);
// }
//
// nestedServices.put(nestedSite, service);
// }
//
// return service;
// }
//
// public String[] getScopes() {
// if (disposed) {
// return null;
// }
//
// // Get the nested scopes, if any.
// final String[] nestedScopes;
// if (activeService == null) {
// nestedScopes = null;
// } else {
// nestedScopes = activeService.getScopes();
// }
//
// // Build the list of active scopes
// final Set activeScopes = new HashSet();
// activeScopes.addAll(enabledContextIds);
// if (nestedScopes != null) {
// for (int i = 0; i < nestedScopes.length; i++) {
// activeScopes.add(nestedScopes[i]);
// }
// }
//
// return (String[]) activeScopes.toArray(new String[activeScopes.size()]);
// }
//
// /**
// * Replaces the active workbench site with this service's active workbench
// * site. This ensures that the context manager will recognize the context as
// * active. Note: this method modifies the list in place; it is
// * <em>destructive</em>.
// *
// * @param submissionsToModify
// * The submissions list to modify; must not be <code>null</code>,
// * but may be empty.
// */
// private final void normalizeSites(final List submissionsToModify) {
// if (disposed) {
// return;
// }
//
// final int size = submissionsToModify.size();
// for (int i = 0; i < size; i++) {
// final Object submission = submissionsToModify.get(i);
// final Object replacementSubmission;
//
// if (submission instanceof EnabledSubmission) {
// final EnabledSubmission enabledSubmission = (EnabledSubmission) submission;
// if (!workbenchPartSite.equals(enabledSubmission
// .getActiveWorkbenchPartSite())) {
// replacementSubmission = new EnabledSubmission(null,
// enabledSubmission.getActiveShell(),
// workbenchPartSite, enabledSubmission.getContextId());
// } else {
// replacementSubmission = enabledSubmission;
// }
//
// } else if (submission instanceof HandlerSubmission) {
// final HandlerSubmission handlerSubmission = (HandlerSubmission) submission;
// if (!workbenchPartSite.equals(handlerSubmission
// .getActiveWorkbenchPartSite())) {
// replacementSubmission = new HandlerSubmission(null,
// handlerSubmission.getActiveShell(),
// workbenchPartSite,
// handlerSubmission.getCommandId(), handlerSubmission
// .getHandler(), handlerSubmission
// .getPriority());
// } else {
// replacementSubmission = handlerSubmission;
// }
//
// } else {
// replacementSubmission = submission;
// }
//
// submissionsToModify.set(i, replacementSubmission);
// }
//
// }
//
// public void registerAction(IAction action) {
// if (disposed) {
// return;
// }
//
// if (action instanceof CommandLegacyActionWrapper) {
// // this is a registration of a fake action for an already
// // registered handler
// WorkbenchPlugin
// .log("Cannot register a CommandLegacyActionWrapper back into the system"); //$NON-NLS-1$
// return;
// }
//
// if (action instanceof CommandAction) {
// // we unfortunately had to allow these out into the wild, but they
// // still must not feed back into the system
// return;
// }
//
// unregisterAction(action);
// String commandId = action.getActionDefinitionId();
// if (commandId != null) {
// /*
// * If I have a parent and I'm active, de-activate myself while
// * making changes.
// */
// boolean active = false;
// if ((parent != null) && (parent.activeService == this)) {
// active = true;
// parent.deactivateNestedService();
// }
//
// // Create the new submission
// IHandler handler = new ActionHandler(action);
// HandlerSubmission handlerSubmission = new HandlerSubmission(null,
// workbenchPartSite.getShell(), workbenchPartSite, commandId,
// handler, Priority.MEDIUM);
// handlerSubmissionsByCommandId.put(commandId, handlerSubmission);
//
// // Either submit the new handler myself, or simply re-activate.
// if (parent != null) {
// if (active) {
// parent.activateNestedService(this);
// }
// } else {
// PlatformUI.getWorkbench().getCommandSupport()
// .addHandlerSubmission(handlerSubmission);
// }
// }
// }
//
// /*
// * (non-Javadoc)
// *
// * @see org.eclipse.ui.INestableKeyBindingService#removeKeyBindingService(org.eclipse.ui.IWorkbenchSite)
// */
// public boolean removeKeyBindingService(IWorkbenchSite nestedSite) {
// if (disposed) {
// return false;
// }
//
// final IKeyBindingService service = (IKeyBindingService) nestedServices
// .remove(nestedSite);
// if (service == null) {
// return false;
// }
//
// if (service.equals(activeService)) {
// deactivateNestedService();
// }
//
// return true;
// }
//
// public void setScopes(String[] scopes) {
// if (disposed) {
// return;
// }
//
// // Either deactivate myself, or remove the previous submissions myself.
// boolean active = false;
// if ((parent != null) && (parent.activeService == this)) {
// active = true;
// parent.deactivateNestedService();
// } else {
// PlatformUI.getWorkbench().getContextSupport()
// .removeEnabledSubmissions(enabledSubmissions);
// }
// enabledSubmissions.clear();
//
// // Determine the new list of submissions.
// enabledContextIds = new HashSet(Arrays.asList(scopes));
// for (Iterator iterator = enabledContextIds.iterator(); iterator
// .hasNext();) {
// String contextId = (String) iterator.next();
// enabledSubmissions.add(new EnabledSubmission(null, null,
// workbenchPartSite, contextId));
// }
//
// // Submit the new contexts myself, or simply re-active myself.
// if (parent != null) {
// if (active) {
// parent.activateNestedService(this);
// }
// } else {
// PlatformUI.getWorkbench().getContextSupport().addEnabledSubmissions(
// enabledSubmissions);
// }
// }
//
// public void unregisterAction(IAction action) {
// if (disposed) {
// return;
// }
//
// if (action instanceof CommandLegacyActionWrapper) {
// // this is a registration of a fake action for an already
// // registered handler
// WorkbenchPlugin
// .log("Cannot unregister a CommandLegacyActionWrapper out of the system"); //$NON-NLS-1$
// return;
// }
//
// String commandId = action.getActionDefinitionId();
//
// if (commandId != null) {
// // Deactivate this service while making changes.
// boolean active = false;
// if ((parent != null) && (parent.activeService == this)) {
// active = true;
// parent.deactivateNestedService();
// }
//
// // Remove the current submission, if any.
// HandlerSubmission handlerSubmission = (HandlerSubmission) handlerSubmissionsByCommandId
// .remove(commandId);
//
// /*
// * Either activate this service again, or remove the submission
// * myself.
// */
// if (parent != null) {
// if (active) {
// parent.activateNestedService(this);
// }
// } else {
// if (handlerSubmission != null) {
// PlatformUI.getWorkbench().getCommandSupport()
// .removeHandlerSubmission(handlerSubmission);
// handlerSubmission.getHandler().dispose();
// }
// }
// }
// }
//}